Page({
    data: {
        // 项目数据
        zones: [
        ],

        // 未关联项目的人员数据
        unassignedPersons: [],

        // 弹窗控制
        showZoneModal: false,
        showPersonModal: false,
        showTagsModal: false,

        // 悬浮人员池控制
        showFloatingPool: false,
        floatingPoolVisible: false,
        userClosedFloatingPool: false, // 用户是否手动关闭了悬浮人员池
        hasScrolledToTop: true, // 是否已经滚动到顶部

        // 当前编辑的数据
        currentZone: { name: '', startDate: '' },
        currentPerson: { name: '', zoneId: 0 },
        selectedPerson: { name: '', tags: [] },

        // 模态框标题
        zoneModalTitle: '添加项目',
        personModalTitle: '添加人员',

        // 模态框按钮配置
        zoneModalActions: [
            { name: '取消', color: '#999' },
            { name: '确定', color: '#2d8cf0' }
        ],
        personModalActions: [
            { name: '取消', color: '#999' },
            { name: '确定', color: '#2d8cf0' }
        ],
        tagsModalActions: [
            { name: '关闭', color: '#2d8cf0' }
        ],

        // 拖拽相关
        touchStarted: false,
        isDragging: false,
        draggingPerson: null,
        dragBallPosition: { x: 0, y: 0 },
        startPosition: { x: 0, y: 0 },

        // 长按相关
        longPressTimer: null,
        longPressTriggered: false,

        // 双击检测相关
        lastTapTime: 0,
        tapTimeout: null,

        // 选择器数据
        zonePickerArray: [],
        currentPersonZoneIndex: 0,

        // 标签相关
        newTag: '',

        // 数据生成器
        nextZoneId: 3,
        nextPersonId: 4
    },

    onLoad() {
        this.updateZonePickerArray();
        this.loadProjectsFromServer();
        this.loadUnassignedPersons();

        // 显示操作提示
        setTimeout(() => {
            wx.showToast({
                title: '双击查看标签，长按移除人员，拖拽移动项目',
                icon: 'none',
                duration: 4000
            });
        }, 1000);
    },

    onShow() {
        // 每次显示页面时重新加载数据，确保数据同步
        this.loadProjectsFromServer();
        this.loadUnassignedPersons();
    },

    /**
     * 页面滚动监听
     */
    onPageScroll(e) {
        const scrollTop = e.scrollTop;
        const hasUnassignedPersons = this.data.unassignedPersons.length > 0;

        // 更新是否已经滚动到顶部的状态
        const isAtTop = scrollTop <= 0;
        if (this.data.hasScrolledToTop !== isAtTop) {
            this.setData({
                hasScrolledToTop: isAtTop
            });

            // 如果回到顶部，重置用户手动关闭状态
            if (isAtTop && this.data.userClosedFloatingPool) {
                this.setData({
                    userClosedFloatingPool: false
                });
                console.log('回到顶部，重置用户手动关闭状态');
            }
        }

        // 只有在有未分配人员时才显示悬浮人员池
        if (!hasUnassignedPersons) {
            if (this.data.showFloatingPool) {
                this.setData({
                    showFloatingPool: false,
                    floatingPoolVisible: false
                });
            }
            return;
        }

        // 如果用户手动关闭了悬浮人员池，则不再显示
        if (this.data.userClosedFloatingPool) {
            return;
        }

        // 滚动超过400px时显示悬浮人员池
        const shouldShowFloating = scrollTop > 400;

        if (this.data.showFloatingPool !== shouldShowFloating) {
            this.setData({
                showFloatingPool: shouldShowFloating
            });

            // 延迟设置可见性，配合动画效果
            if (shouldShowFloating) {
                setTimeout(() => {
                    this.setData({
                        floatingPoolVisible: true
                    });
                }, 50);
            } else {
                this.setData({
                    floatingPoolVisible: false
                });
            }
        }
    },

    /**
     * 从服务器加载项目数据
     */
    loadProjectsFromServer() {
        const app = getApp();
        wx.request({
            url: app.globalData.api + '/ProjectManager/GetProjectsWithPersons',
            data: {
                token: app.globalData.userInfo.token
            },
            method: 'GET',
            success: (res) => {
                if (res.data.resultCode === 0) { // 0表示成功
                    this.setData({
                        zones: res.data.data || []
                    });
                    this.updateZonePickerArray();
                } else {
                    wx.showToast({
                        title: res.data.message || '加载数据失败',
                        icon: 'none'
                    });
                }
            },
            fail: (err) => {
                console.error('加载项目数据失败:', err);
                wx.showToast({
                    title: '网络请求失败',
                    icon: 'none'
                });
            }
        });
    },

    /**
     * 从服务器加载未关联项目的人员数据
     */
    loadUnassignedPersons() {
        const app = getApp();
        wx.request({
            url: app.globalData.api + '/ProjectManager/GetUnassignedPersons',
            data: {
                token: app.globalData.userInfo.token
            },
            method: 'GET',
            success: (res) => {
                if (res.data.resultCode === 0) {
                    this.setData({
                        unassignedPersons: res.data.data || []
                    });
                } else {
                    console.error('加载未关联人员数据失败:', res.data.message);
                }
            },
            fail: (err) => {
                console.error('加载未关联人员数据失败:', err);
            }
        });
    },

    /**
     * 更新项目选择器数组
     */
    updateZonePickerArray() {
        const zoneNames = ['人员池', ...this.data.zones.map(zone => zone.name)];
        this.setData({
            zonePickerArray: zoneNames
        });
    },

    /**
     * 生成随机颜色渐变
     */
    generateRandomColor() {
        const gradients = [
            // 深色调渐变，确保白色文字清晰可见
            'linear-gradient(135deg, #667eea 0%, #764ba2 100%)', // 深紫色
            'linear-gradient(135deg, #f093fb 0%, #c44569 100%)', // 深粉色
            'linear-gradient(135deg, #4facfe 0%, #00a8e6 100%)', // 深蓝色
            'linear-gradient(135deg, #43e97b 0%, #38a3a5 100%)', // 深绿色
            'linear-gradient(135deg, #fa709a 0%, #e74c3c 100%)', // 深红色
            'linear-gradient(135deg, #ff6b6b 0%, #c44569 100%)', // 红粉渐变
            'linear-gradient(135deg, #667eea 0%, #2980b9 100%)', // 蓝紫渐变
            'linear-gradient(135deg, #27ae60 0%, #16a085 100%)', // 绿色渐变
            'linear-gradient(135deg, #e74c3c 0%, #c0392b 100%)', // 深红渐变
            'linear-gradient(135deg, #9b59b6 0%, #8e44ad 100%)', // 深紫渐变
            'linear-gradient(135deg, #f39c12 0%, #d35400 100%)', // 橙色渐变
            'linear-gradient(135deg, #2c3e50 0%, #34495e 100%)'  // 深灰渐变
        ];
        return gradients[Math.floor(Math.random() * gradients.length)];
    },

    /**
     * 根据姓名查找人员
     */
    findPersonByName(name) {
        for (let zone of this.data.zones) {
            for (let person of zone.persons) {
                if (person.name === name) {
                    return {
                        person: person,
                        zoneName: zone.name,
                        zoneId: zone.id
                    };
                }
            }
        }
        return null;
    },

    /**
     * 添加项目
     */
    addZone() {
        // 获取当前日期作为默认开始日期
        const today = new Date();
        const defaultDate = today.getFullYear() + '-' +
            String(today.getMonth() + 1).padStart(2, '0') + '-' +
            String(today.getDate()).padStart(2, '0');

        this.setData({
            showZoneModal: true,
            zoneModalTitle: '添加项目',
            currentZone: { name: '', startDate: defaultDate }
        });
    },

    /**
     * 编辑项目
     */
    editZone(e) {
        console.log('editZone被调用', e.currentTarget.dataset);
        const zoneId = parseInt(e.currentTarget.dataset.zoneId || e.currentTarget.dataset.zoneid);
        console.log('editZone zoneId:', zoneId);
        const zone = this.data.zones.find(z => z.id === zoneId);
        console.log('要编辑的项目:', zone);

        if (!zone) {
            wx.showToast({
                title: '项目不存在',
                icon: 'none'
            });
            return;
        }

        this.setData({
            showZoneModal: true,
            zoneModalTitle: '编辑项目',
            currentZone: { ...zone }
        });
        console.log('编辑项目弹窗应该显示');
    },

    /**
     * 删除区域
     */
    deleteZone(e) {
        console.log('deleteZone called', e.currentTarget.dataset);
        const zoneId = parseInt(e.currentTarget.dataset.zoneId || e.currentTarget.dataset.zoneid);
        console.log('zoneId:', zoneId);
        const zone = this.data.zones.find(z => z.id === zoneId);

        if (!zone) {
            wx.showToast({
                title: '项目不存在',
                icon: 'none'
            });
            return;
        }

        wx.showModal({
            title: '确认删除',
            content: `确定要删除项目"${zone.name}"吗？项目内的人员将被移除。`,
            success: (res) => {
                if (res.confirm) {
                    const app = getApp();
                    wx.request({
                        url: app.globalData.api + '/ProjectManager/DeleteProject',
                        data: {
                            token: app.globalData.userInfo.token,
                            id: zoneId
                        },
                        method: 'GET',
                        success: (apiRes) => {
                            if (apiRes.data.resultCode === 0) {
                                wx.showToast({
                                    title: '删除成功',
                                    icon: 'success'
                                });
                                // 重新加载数据
                                this.loadProjectsFromServer();
                            } else {
                                wx.showToast({
                                    title: apiRes.data.message || '删除失败',
                                    icon: 'none'
                                });
                            }
                        },
                        fail: (err) => {
                            console.error('删除项目失败:', err);
                            wx.showToast({
                                title: '网络请求失败',
                                icon: 'none'
                            });
                        }
                    });
                }
            }
        });
    },

    /**
     * 项目名称输入
     */
    onZoneNameChange(e) {
        this.setData({
            "currentZone.name": e.detail.detail.value
        });
    },

    /**
     * 项目开始日期改变
     */
    onZoneStartDateChange(e) {
        this.setData({
            "currentZone.startDate": e.detail.value
        });
    },

    /**
     * 确认项目操作
     */
    confirmZone() {
        const { currentZone } = this.data;

        if (!currentZone.name.trim()) {
            wx.showToast({
                title: '请输入项目名称',
                icon: 'none'
            });
            return;
        }

        if (!currentZone.startDate) {
            wx.showToast({
                title: '请选择开始日期',
                icon: 'none'
            });
            return;
        }

        const app = getApp();
        const isEdit = currentZone.id > 0;
        const url = isEdit
            ? app.globalData.api + '/ProjectManager/UpdateProject'
            : app.globalData.api + '/ProjectManager/CreateProject';

        wx.request({
            url: url,
            data: {
                token: app.globalData.userInfo.token,
                projectName: currentZone.name.trim(),
                startDate: currentZone.startDate,
                ...(isEdit && { id: currentZone.id })
            },
            method: 'GET',
            success: (res) => {
                if (res.data.resultCode === 0) {
                    this.setData({
                        showZoneModal: false
                    });

                    wx.showToast({
                        title: isEdit ? '修改成功' : '添加成功',
                        icon: 'success'
                    });

                    // 重新加载数据
                    this.loadProjectsFromServer();
                } else {
                    wx.showToast({
                        title: res.data.message || '操作失败',
                        icon: 'none'
                    });
                }
            },
            fail: (err) => {
                console.error('项目操作失败:', err);
                wx.showToast({
                    title: '网络请求失败',
                    icon: 'none'
                });
            }
        });
    },

    /**
     * 取消项目操作
     */
    cancelZone() {
        this.setData({
            showZoneModal: false
        });
    },

    /**
     * 项目模态框点击事件
     */
    handleZoneModalClick(e) {
        const index = e.detail.index;
        if (index === 1) {
            // 点击确定
            this.confirmZone();
        } else {
            // 点击取消
            this.cancelZone();
        }
    },

    /**
     * 添加人员
     */
    addPerson() {
        if (this.data.zones.length === 0) {
            wx.showToast({
                title: '请先添加项目',
                icon: 'none'
            });
            return;
        }

        this.setData({
            showPersonModal: true,
            personModalTitle: '添加人员',
            currentPerson: { name: '', zoneId: 0 },
            currentPersonZoneIndex: 0
        });
    },

    /**
     * 人员姓名输入
     */
    onPersonNameChange(e) {
        this.setData({
            "currentPerson.name": e.detail.detail.value
        });
    },

    /**
     * 项目选择器改变
     */
    onZonePickerChange(e) {
        const index = parseInt(e.detail.value);
        const zoneId = this.data.zones[index]?.id || 0;
        const currentPerson = this.data.currentPerson || {};
        this.setData({
            currentPersonZoneIndex: index,
            currentPerson: {
                ...currentPerson,
                zoneId: zoneId
            }
        });
    },

    /**
     * 确认人员操作
     */
    confirmPerson() {
        const { currentPerson, zones, currentPersonZoneIndex } = this.data;

        if (!currentPerson.name.trim()) {
            wx.showToast({
                title: '请输入人员姓名',
                icon: 'none'
            });
            return;
        }

        // 检查是否选择了项目
        if (currentPersonZoneIndex < 0) {
            wx.showToast({
                title: '请选择项目或人员池',
                icon: 'none'
            });
            return;
        }

        // 判断是否选择的是人员池（第一个选项）
        const isPersonPool = currentPersonZoneIndex === 0;
        let projectId = 0; // 0表示未分配项目

        if (!isPersonPool) {
            // 选择的是具体项目，索引需要-1（因为第一个是人员池）
            const targetZone = zones[currentPersonZoneIndex - 1];
            if (!targetZone) {
                wx.showToast({
                    title: '项目不存在',
                    icon: 'none'
                });
                return;
            }
            projectId = targetZone.id;
        }

        const app = getApp();
        wx.request({
            url: app.globalData.api + '/ProjectManager/CreatePerson',
            data: {
                token: app.globalData.userInfo.token,
                personName: currentPerson.name.trim(),
                projectId: projectId,
                personColor: this.generateRandomColor()
            },
            method: 'GET',
            success: (res) => {
                if (res.data.resultCode === 0) {
                    this.setData({
                        showPersonModal: false
                    });

                    wx.showToast({
                        title: '添加成功',
                        icon: 'success'
                    });

                    // 重新加载数据
                    this.loadProjectsFromServer();
                    this.loadUnassignedPersons();
                } else {
                    if (res.data.data && res.data.data.existingPerson) {
                        // 人员已存在，显示提示并问是否查看
                        wx.showModal({
                            title: '人员已存在',
                            content: res.data.message,
                            success: (modalRes) => {
                                if (modalRes.confirm) {
                                    // 显示已存在人员的标签信息
                                    const existingPerson = res.data.data.existingPerson;
                                    this.setData({
                                        selectedPerson: { ...existingPerson },
                                        showTagsModal: true,
                                        showPersonModal: false,
                                        newTag: ''
                                    });
                                } else {
                                    // 用户点击取消，关闭添加人员弹窗
                                    this.setData({
                                        showPersonModal: false
                                    });
                                }
                            }
                        });
                    } else {
                        wx.showToast({
                            title: res.data.message || '添加失败',
                            icon: 'none'
                        });
                    }
                }
            },
            fail: (err) => {
                console.error('添加人员失败:', err);
                wx.showToast({
                    title: '网络请求失败',
                    icon: 'none'
                });
            }
        });
    },

    /**
     * 取消人员操作
     */
    cancelPerson() {
        this.setData({
            showPersonModal: false
        });
    },

    /**
     * 人员模态框点击事件
     */
    handlePersonModalClick(e) {
        const index = e.detail.index;
        if (index === 1) {
            // 点击确定
            this.confirmPerson();
        } else {
            // 点击取消
            this.cancelPerson();
        }
    },

    /**
     * 人员双击检测
     */
    onPersonDoubleTap(e) {
        // 如果正在拖拽，不处理点击事件
        if (this.data.isDragging) {
            console.log('正在拖拽，忽略点击事件');
            return;
        }

        const currentTime = Date.now();
        const lastTapTime = this.data.lastTapTime;
        const timeDiff = currentTime - lastTapTime;

        console.log('点击事件', '时间间隔:', timeDiff);

        // 清除之前的定时器
        if (this.data.tapTimeout) {
            clearTimeout(this.data.tapTimeout);
            this.setData({ tapTimeout: null });
        }

        if (timeDiff < 500 && lastTapTime > 0) {
            // 双击检测成功，显示标签弹窗
            console.log('检测到双击，显示标签弹窗');
            this.showPersonTags(e);
            this.setData({ lastTapTime: 0 });
        } else {
            // 第一次点击，等待第二次点击
            this.setData({ lastTapTime: currentTime });
            const timeout = setTimeout(() => {
                // 超时未有第二次点击，重置状态
                this.setData({
                    lastTapTime: 0,
                    tapTimeout: null
                });
            }, 500);
            this.setData({ tapTimeout: timeout });
        }
    },

    /**
     * 显示人员标签
     */
    showPersonTags(e) {
        console.log('showPersonTags 被调用');

        // 从父元素或当前元素获取数据属性
        const personId = e.currentTarget.parentNode?.dataset?.personId || e.currentTarget.dataset.personId;
        const zoneId = e.currentTarget.parentNode?.dataset?.zoneId || e.currentTarget.dataset.zoneId;
        console.log('personId:', personId, 'zoneId:', zoneId);

        let person = null;

        if (zoneId && zoneId !== 'unassigned') {
            // 在项目中查找
            const zone = this.data.zones.find(z => z.id === parseInt(zoneId));
            person = zone?.persons.find(p => p.id === parseInt(personId));
        } else {
            // 在未分配人员中查找
            person = this.data.unassignedPersons.find(p => p.id === parseInt(personId));
        }

        console.log('找到的人员:', person);

        if (person) {
            this.setData({
                selectedPerson: { ...person },
                showTagsModal: true,
                newTag: ''
            });
            console.log('标签弹窗应该显示');
        }
    },

    /**
     * 处理长按操作
     */
    handleLongPress(personId, zoneId, person) {
        console.log('handleLongPress 被调用', { personId, zoneId, person });

        if (!personId) {
            console.error('无法获取人员ID');
            return;
        }

        // 如果是人员池中的人员，提示已在人员池
        if (zoneId === 'unassigned') {
            wx.showToast({
                title: '该人员已在人员池中',
                icon: 'none',
                duration: 2000
            });
            return;
        }

        // 获取人员信息和所属项目信息
        const zone = this.data.zones.find(z => z.id === parseInt(zoneId));

        if (!person || !zone) {
            wx.showToast({
                title: '人员信息不存在',
                icon: 'none'
            });
            return;
        }

        // 弹出确认对话框
        wx.showModal({
            title: '移除人员',
            content: `确定要将“${person.name}”从“${zone.name}”项目中移除吗？移除后将回到人员池。`,
            success: (res) => {
                if (res.confirm) {
                    this.removePersonFromProject(personId, person.name, zone.name);
                }
            }
        });
    },

    /**
     * 人员长按事件处理（保留原有方法名以保持兼容性）
     */
    onPersonLongPress(e) {
        // 这个方法保留但不再使用，因为我们使用自定义的长按逻辑
        console.log('onPersonLongPress 被调用（已废弃）');
    },

    /**
     * 从项目中移除人员（移动到人员池）
     */
    removePersonFromProject(personId, personName, projectName) {
        console.log('移除人员从项目', 'personId:', personId);

        const app = getApp();
        wx.request({
            url: app.globalData.api + '/ProjectManager/MovePerson',
            data: {
                token: app.globalData.userInfo.token,
                personId: personId,
                targetProjectId: 0  // 0表示移动到人员池
            },
            method: 'GET',
            success: (res) => {
                if (res.data.resultCode === 0) {
                    wx.showToast({
                        title: `${personName}已移除到人员池`,
                        icon: 'success',
                        duration: 2000
                    });
                    // 重新加载数据
                    this.loadProjectsFromServer();
                    this.loadUnassignedPersons();
                } else {
                    wx.showToast({
                        title: res.data.message || '移除失败',
                        icon: 'none'
                    });
                }
            },
            fail: (err) => {
                console.error('移除人员失败:', err);
                wx.showToast({
                    title: '网络请求失败',
                    icon: 'none'
                });
            }
        });
    },

    /**
     * 关闭标签弹窗
     */
    closeTagsModal() {
        this.setData({
            showTagsModal: false
        });
    },

    /**
     * 标签模态框点击事件
     */
    handleTagsModalClick(e) {
        // 点击关闭按钮
        this.closeTagsModal();
    },

    /**
     * 新标签输入
     */
    onNewTagChange(e) {
        this.setData({
            newTag: e.detail.detail.value
        });
    },

    /**
     * 添加标签
     */
    addTag() {
        const { newTag, selectedPerson } = this.data;

        if (!newTag.trim()) {
            wx.showToast({
                title: '请输入标签内容',
                icon: 'none'
            });
            return;
        }

        const trimmedTag = newTag.trim();

        if (selectedPerson.tags.some(tag => tag.name === trimmedTag)) {
            wx.showToast({
                title: '标签已存在',
                icon: 'none'
            });
            return;
        }

        const app = getApp();
        wx.request({
            url: app.globalData.api + '/ProjectManager/AddPersonTag',
            data: {
                token: app.globalData.userInfo.token,
                personId: selectedPerson.id,
                tagName: trimmedTag
            },
            method: 'GET',
            success: (res) => {
                if (res.data.resultCode === 0) {
                    // 更新本地显示
                    const newTagObj = {
                        id: res.data.data.id,
                        name: res.data.data.tagName
                    };

                    const updatedPerson = {
                        ...selectedPerson,
                        tags: [...selectedPerson.tags, newTagObj]
                    };

                    // 更新zones数据
                    let newZones = [...this.data.zones];
                    let newUnassignedPersons = [...this.data.unassignedPersons];
                    let found = false;

                    // 先在项目中查找并更新
                    for (let zone of newZones) {
                        const personIndex = zone.persons.findIndex(p => p.id === selectedPerson.id);
                        if (personIndex !== -1) {
                            zone.persons[personIndex] = {
                                ...zone.persons[personIndex],
                                tags: updatedPerson.tags
                            };
                            found = true;
                            break;
                        }
                    }

                    // 如果在项目中未找到，在未分配人员中查找并更新
                    if (!found) {
                        const personIndex = newUnassignedPersons.findIndex(p => p.id === selectedPerson.id);
                        if (personIndex !== -1) {
                            newUnassignedPersons[personIndex] = {
                                ...newUnassignedPersons[personIndex],
                                tags: updatedPerson.tags
                            };
                        }
                    }

                    this.setData({
                        zones: newZones,
                        unassignedPersons: newUnassignedPersons,
                        selectedPerson: updatedPerson,
                        newTag: ''
                    });

                    wx.showToast({
                        title: '添加成功',
                        icon: 'success'
                    });
                } else {
                    wx.showToast({
                        title: res.data.message || '添加失败',
                        icon: 'none'
                    });
                }
            },
            fail: (err) => {
                console.error('添加标签失败:', err);
                wx.showToast({
                    title: '网络请求失败',
                    icon: 'none'
                });
            }
        });
    },

    /**
     * 删除标签
     */
    deleteTag(e) {
        console.log('deleteTag被调用', e);
        const index = e.currentTarget.dataset.index;
        console.log('要删除的标签索引:', index);
        const { selectedPerson, zones } = this.data;
        console.log('当前选中人员:', selectedPerson);

        if (index === undefined || index === null) {
            console.error('标签索引未定义');
            wx.showToast({
                title: '删除失败：索引错误',
                icon: 'none'
            });
            return;
        }

        const tagToDelete = selectedPerson.tags[parseInt(index)];
        console.log('要删除的标签:', tagToDelete);

        if (!tagToDelete || !tagToDelete.id) {
            wx.showToast({
                title: '删除失败：标签不存在',
                icon: 'none'
            });
            return;
        }

        // 调用删除标签API
        const app = getApp();
        wx.request({
            url: app.globalData.api + '/ProjectManager/DeletePersonTag',
            data: {
                token: app.globalData.userInfo.token,
                tagId: tagToDelete.id
            },
            method: 'GET',
            success: (res) => {
                if (res.data.resultCode === 0) {
                    // 更新选中人员的标签
                    const updatedTags = selectedPerson.tags.filter((_, i) => i !== parseInt(index));
                    console.log('更新后的标签:', updatedTags);
                    const updatedPerson = {
                        ...selectedPerson,
                        tags: updatedTags
                    };

                    // 更新zones数据
                    let newZones = [...zones];
                    let newUnassignedPersons = [...this.data.unassignedPersons];
                    let found = false;

                    // 先在项目中查找并更新
                    for (let zone of newZones) {
                        const personIndex = zone.persons.findIndex(p => p.id === selectedPerson.id);
                        if (personIndex !== -1) {
                            zone.persons[personIndex] = updatedPerson;
                            found = true;
                            console.log('已更新zones数据');
                            break;
                        }
                    }

                    // 如果在项目中未找到，在未分配人员中查找并更新
                    if (!found) {
                        const personIndex = newUnassignedPersons.findIndex(p => p.id === selectedPerson.id);
                        if (personIndex !== -1) {
                            newUnassignedPersons[personIndex] = updatedPerson;
                            console.log('已更新未分配人员数据');
                        }
                    }

                    this.setData({
                        zones: newZones,
                        unassignedPersons: newUnassignedPersons,
                        selectedPerson: updatedPerson
                    });

                    wx.showToast({
                        title: '删除成功',
                        icon: 'success'
                    });
                } else {
                    wx.showToast({
                        title: res.data.message || '删除失败',
                        icon: 'none'
                    });
                }
            },
            fail: (err) => {
                console.error('删除标签失败:', err);
                wx.showToast({
                    title: '网络请求失败',
                    icon: 'none'
                });
            }
        });
    },

    /**
     * 人员拖拽开始
     */
    onPersonTouchStart(e) {
        console.log('onPersonTouchStart 被调用', e.currentTarget.dataset);
        const personId = parseInt(e.currentTarget.dataset.personId);
        const zoneId = e.currentTarget.dataset.zoneId;
        console.log('触摸开始 - personId:', personId, 'zoneId:', zoneId);

        if (!personId) {
            console.error('无法获取人员ID');
            return;
        }

        let person = null;

        if (zoneId === 'unassigned') {
            // 从未分配人员中查找
            person = this.data.unassignedPersons.find(p => p.id === personId);
        } else {
            // 从项目中查找
            const zone = this.data.zones.find(z => z.id === parseInt(zoneId));
            person = zone?.persons.find(p => p.id === personId);
        }

        console.log('找到的人员:', person);

        if (person) {
            const touch = e.touches[0];

            // 清除之前的定时器
            if (this.data.longPressTimer) {
                clearTimeout(this.data.longPressTimer);
            }

            this.setData({
                // 不立即设为拖拽状态，先记录触摸信息
                touchStarted: true,
                draggingPerson: person,
                startPosition: { x: touch.clientX, y: touch.clientY },
                dragBallPosition: { x: touch.clientX - 60, y: touch.clientY - 60 },
                longPressTriggered: false
            });

            // 设置长按定时器（800ms）
            const longPressTimer = setTimeout(() => {
                console.log('长按触发');
                this.setData({
                    longPressTriggered: true
                });
                this.handleLongPress(personId, zoneId, person);
            }, 800);

            this.setData({
                longPressTimer: longPressTimer
            });

            console.log('触摸状态已设置');
        } else {
            console.error('未找到人员信息');
        }
    },

    /**
     * 人员拖拽移动
     */
    onPersonTouchMove(e) {
        if (!this.data.touchStarted) {
            console.log('未开始触摸，忽略移动事件');
            return;
        }

        const touch = e.touches[0];
        const { startPosition } = this.data;

        // 计算移动距离
        const deltaX = Math.abs(touch.clientX - startPosition.x);
        const deltaY = Math.abs(touch.clientY - startPosition.y);
        const distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);

        console.log('移动距离:', distance, '当前拖拽状态:', this.data.isDragging);

        // 如果移动距离超过10像素，则认为是拖拽，取消长按
        if (distance > 10 && !this.data.isDragging) {
            console.log('进入拖拽模式，取消长按');

            // 清除长按定时器
            if (this.data.longPressTimer) {
                clearTimeout(this.data.longPressTimer);
                this.setData({
                    longPressTimer: null
                });
            }

            this.setData({
                isDragging: true
            });
        }

        if (this.data.isDragging) {
            this.setData({
                dragBallPosition: {
                    x: touch.clientX - 60,
                    y: touch.clientY - 60
                }
            });

            // 检查当前位置是否在某个项目上方，为其添加高亮效果
            this.checkDropZoneHighlight(touch.clientX, touch.clientY);
        }
    },

    /**
     * 人员拖拽结束
     */
    onPersonTouchEnd(e) {
        console.log('触摸结束', '是否正在拖拽:', this.data.isDragging, '长按是否触发:', this.data.longPressTriggered);
        const wasDragging = this.data.isDragging;
        const { draggingPerson } = this.data; // 在重置前保存引用

        // 清除长按定时器
        if (this.data.longPressTimer) {
            clearTimeout(this.data.longPressTimer);
        }

        // 重置状态
        this.setData({
            touchStarted: false,
            isDragging: false,
            draggingPerson: null,
            longPressTimer: null,
            longPressTriggered: false
        });

        // 如果触发了长按，不处理拖拽逻辑
        if (this.data.longPressTriggered) {
            console.log('已触发长按，忽略拖拽逻辑');
            return;
        }

        // 如果不是拖拽，则不处理移动逻辑
        if (!wasDragging) {
            console.log('不是拖拽操作，忽略');
            return;
        }

        const touch = e.changedTouches[0];
        console.log('开始处理拖拽移动，触摸位置:', touch.clientX, touch.clientY);
        console.log('拖拽人员信息:', draggingPerson);

        // 获取所有项目容器元素
        const query = wx.createSelectorQuery();
        // 只选择项目区域的人员容器，排除人员池
        query.selectAll('.zones-container .zone .persons-container').boundingClientRect().exec((res) => {
            console.log('项目容器信息:', res[0]);
            const rects = res[0];
            
            // 使用精确查找方法确定目标区域
            const targetZone = this.findDropZone(touch.clientX, touch.clientY, rects);
            let targetZoneId = null;
            let targetZoneIndex = -1;

            if (targetZone) {
                targetZoneIndex = targetZone.index;
                targetZoneId = targetZone.id;
                console.log('找到目标项目 ID:', targetZoneId, '索引:', targetZoneIndex);
            }

            if (targetZoneId && draggingPerson) {
                console.log('开始移动人员到项目:', targetZoneId);
                this.movePersonToZone(draggingPerson.id, targetZoneId);
            } else {
                console.log('未找到目标项目或人员信息', '目标项目id:', targetZoneId, '拖拽人员:', draggingPerson);
                
                // 如果没有找到目标区域，给出用户提示
                if (draggingPerson) {
                    wx.showToast({
                        title: '请将人员拖拽到项目区域内',
                        icon: 'none'
                    });
                }
            }
        });
    },

    /**
     * 移动人员到指定项目
     */
    movePersonToZone(personId, targetZoneId) {
        console.log('移动人员到指定项目', 'personId:', personId, 'targetZoneId:', targetZoneId);

        const person = this.findPersonById(personId);
        const targetZone = this.data.zones.find(z => z.id === targetZoneId);

        if (!person || !targetZone) {
            console.error('人员或目标项目不存在');
            return;
        }

        // 如果已经在目标项目中，不进行移动
        if (!person.isUnassigned && person.zone && person.zone.id === targetZoneId) {
            console.log('目标项目与源项目相同，不进行移动');
            return;
        }

        const app = getApp();
        wx.request({
            url: app.globalData.api + '/ProjectManager/MovePerson',
            data: {
                token: app.globalData.userInfo.token,
                personId: personId,
                targetProjectId: targetZoneId
            },
            method: 'GET',
            success: (res) => {
                if (res.data.resultCode === 0) {
                    wx.showToast({
                        title: res.data.message || `${person.person.name}已移动到${targetZone.name}`,
                        icon: 'success'
                    });
                    // 重新加载数据
                    this.loadProjectsFromServer();
                    this.loadUnassignedPersons();
                } else {
                    wx.showToast({
                        title: res.data.message || '移动失败',
                        icon: 'none'
                    });
                }
            },
            fail: (err) => {
                console.error('移动人员失败:', err);
                wx.showToast({
                    title: '网络请求失败',
                    icon: 'none'
                });
            }
        });
    },

    /**
     * 根据ID查找人员和所属项目
     */
    findPersonById(personId) {
        // 先在项目中查找
        for (let zone of this.data.zones) {
            for (let person of zone.persons) {
                if (person.id === personId) {
                    return {
                        person: person,
                        zone: zone,
                        isUnassigned: false
                    };
                }
            }
        }

        // 在未分配人员中查找
        for (let person of this.data.unassignedPersons) {
            if (person.id === personId) {
                return {
                    person: person,
                    zone: null,
                    isUnassigned: true
                };
            }
        }

        return null;
    },

    /**
     * 检查放置项目高亮
     */
    checkDropZoneHighlight(x, y) {
        const query = wx.createSelectorQuery();
        // 只选择项目区域的人员容器，排除人员池
        query.selectAll('.zones-container .zone .persons-container').boundingClientRect().exec((res) => {
            const rects = res[0];
            let highlightedZoneIndex = -1;

            // 查找应该高亮的区域
            for (let i = 0; i < rects.length; i++) {
                const rect = rects[i];
                const isOver = x >= rect.left && x <= rect.right && y >= rect.top && y <= rect.bottom;

                // 通过动态添加/移除class来实现高亮效果
                const selector = `.zones-container .zone:nth-child(${i + 1}) .persons-container`;
                if (isOver) {
                    // 添加高亮样式
                    wx.createSelectorQuery().select(selector).fields({
                        node: true
                    }).exec((nodeRes) => {
                        if (nodeRes[0] && nodeRes[0].node) {
                            nodeRes[0].node.classList.add('drop-zone');
                        }
                    });
                    highlightedZoneIndex = i;
                } else {
                    // 移除高亮样式
                    wx.createSelectorQuery().select(selector).fields({
                        node: true
                    }).exec((nodeRes) => {
                        if (nodeRes[0] && nodeRes[0].node) {
                            nodeRes[0].node.classList.remove('drop-zone');
                        }
                    });
                }
            }

            // 如果没有找到精确匹配，尝试扩展范围高亮
            if (highlightedZoneIndex === -1) {
                for (let i = 0; i < rects.length; i++) {
                    const rect = rects[i];
                    // 扩大检测范围
                    const extendedLeft = rect.left - 50;
                    const extendedRight = rect.right + 50;
                    const extendedTop = rect.top - 50;
                    const extendedBottom = rect.bottom + 50;
                    const isNear = x >= extendedLeft && x <= extendedRight && y >= extendedTop && y <= extendedBottom;

                    const selector = `.zones-container .zone:nth-child(${i + 1}) .persons-container`;
                    if (isNear) {
                        // 添加高亮样式
                        wx.createSelectorQuery().select(selector).fields({
                            node: true
                        }).exec((nodeRes) => {
                            if (nodeRes[0] && nodeRes[0].node) {
                                nodeRes[0].node.classList.add('drop-zone');
                            }
                        });
                    }
                }
            }
        });
    },

    /**
     * 精确查找拖拽目标区域
     */
    findDropZone(x, y, rects) {
        // 首先尝试精确匹配
        for (let i = 0; i < rects.length; i++) {
            const rect = rects[i];
            if (x >= rect.left && x <= rect.right && y >= rect.top && y <= rect.bottom) {
                return { index: i, id: this.data.zones[i]?.id };
            }
        }

        // 如果没有精确匹配，尝试扩展范围匹配
        for (let i = 0; i < rects.length; i++) {
            const rect = rects[i];
            // 扩大检测范围，增加容错性
            const extendedLeft = rect.left - 50;
            const extendedRight = rect.right + 50;
            const extendedTop = rect.top - 50;
            const extendedBottom = rect.bottom + 50;

            if (x >= extendedLeft && x <= extendedRight && y >= extendedTop && y <= extendedBottom) {
                return { index: i, id: this.data.zones[i]?.id };
            }
        }

        // 如果还是没有找到，尝试最近的区域
        let closestZone = null;
        let minDistance = Infinity;

        for (let i = 0; i < rects.length; i++) {
            const rect = rects[i];
            // 计算点到矩形中心的距离
            const centerX = (rect.left + rect.right) / 2;
            const centerY = (rect.top + rect.bottom) / 2;
            const distance = Math.sqrt(Math.pow(x - centerX, 2) + Math.pow(y - centerY, 2));

            if (distance < minDistance) {
                minDistance = distance;
                closestZone = { index: i, id: this.data.zones[i]?.id };
            }
        }

        // 如果最近的距离在合理范围内，则返回最近的区域
        if (minDistance < 200) { // 200像素以内的距离认为是合理的
            return closestZone;
        }

        return null;
    },

    /**
     * 关闭悬浮人员池
     */
    closeFloatingPool() {
        // 标记用户手动关闭了悬浮人员池
        this.setData({
            userClosedFloatingPool: true,
            floatingPoolVisible: false
        });

        // 延迟隐藏整个悬浮池
        setTimeout(() => {
            this.setData({
                showFloatingPool: false
            });
        }, 300);
    },

    /**
     * 跳转到人员管理页面
     */
    goToPersonManager() {
        wx.navigateTo({
            url: '/pages/person-manager/index'
        });
    }
});